home *** CD-ROM | disk | FTP | other *** search
/ Hottest 6 / Hottest 6 (1996)(PDSoft)[!].iso / software / programming / c / sri / src / sri.c < prev   
C/C++ Source or Header  |  1978-11-24  |  6KB  |  292 lines
  1.  
  2. #include <exec/lists.h>
  3. #include <libraries/dos.h>
  4. #include <rexx/rxslib.h>
  5. #include <rexx/errors.h>
  6.  
  7. #include <clib/rexxsyslib_protos.h>
  8. #include <proto/dos.h>
  9. #include <proto/exec.h>
  10.  
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <stdlib.h>
  14.  
  15. char *VersionString = "$VER: SAS/C Rexx Interface V1.00";
  16. char *_procname = "Oh-no! More LSE";
  17.  
  18. #ifndef DEBUG
  19. extern BPTR _Backstdout;
  20. #endif
  21.  
  22. struct RxsLib *RexxSysBase;
  23.  
  24. #pragma libcall RexxSysBase CreateArgstring 7E 0802
  25. #pragma libcall RexxSysBase DeleteArgstring 84 801
  26. #pragma libcall RexxSysBase CreateRexxMsg 90 09803
  27. #pragma libcall RexxSysBase DeleteRexxMsg 96 801
  28.  
  29. #define LSE_PORT_NAME "Lse"
  30.  
  31. char *Commands[] ={"OW","LE","NE","QU",NULL};
  32.  
  33. struct Error
  34.  {
  35.   struct Node Err_Node;
  36.   LONG Err_Line;
  37.   char Err_Text[256];
  38.  };
  39. struct List ErrorList;
  40.  
  41. struct MsgPort *CreateRexxPort(char *Name)
  42.  
  43. {
  44.  struct MsgPort *NewRexxPort;
  45.  
  46.  Forbid();
  47.  if (FindPort(Name)) NewRexxPort=NULL;
  48.  else NewRexxPort=CreatePort(Name,0);
  49.  Permit();
  50.  
  51.  return NewRexxPort;
  52. }
  53.  
  54. LONG SendRexxMsg(char *Command)
  55.  
  56. {
  57.  struct MsgPort *ReplyPort,*TargetPort;
  58.  struct RexxMsg *OutRexxMsg;
  59.  UBYTE *CmdArgstring;
  60.  
  61.  if (ReplyPort=CreatePort(NULL,0))
  62.   {
  63.    if (OutRexxMsg=CreateRexxMsg(ReplyPort,NULL,RXSDIR))
  64.     {
  65.      if (CmdArgstring=CreateArgstring(Command,strlen(Command)))
  66.       {
  67. #ifdef DEBUG
  68.        OutRexxMsg->rm_Action=RXCOMM;
  69. #else
  70.        OutRexxMsg->rm_Action=RXCOMM|RXFF_NOIO;
  71. #endif
  72.        OutRexxMsg->rm_Args[0]=(STRPTR)CmdArgstring;
  73.  
  74.        Forbid();
  75.        if (TargetPort=FindPort(RXSDIR))
  76.         {
  77.          PutMsg (TargetPort,&OutRexxMsg->rm_Node);
  78.          Permit();
  79.  
  80.          (void)WaitPort(ReplyPort);
  81.          (void)GetMsg(ReplyPort);
  82.  
  83. #ifdef DEBUG
  84.          printf ("OUT: %s\n",CmdArgstring);
  85. #endif
  86.          DeleteArgstring (CmdArgstring);
  87.          DeleteRexxMsg (OutRexxMsg);
  88.          DeletePort (ReplyPort);
  89.  
  90.          return TRUE;
  91.         }
  92.        Permit();
  93.        DeleteArgstring (CmdArgstring);
  94.       }
  95.      DeleteRexxMsg (OutRexxMsg);
  96.     }
  97.    DeletePort (ReplyPort);
  98.   }
  99.  
  100.  return FALSE;
  101. }
  102.  
  103. void SetResult(struct RexxMsg *RexxMsg,LONG Result)
  104.  
  105. {
  106.  RexxMsg->rm_Result1=Result;
  107.  RexxMsg->rm_Result2=NULL;
  108. }
  109.  
  110. char *BaseName(char *FileName)
  111.  
  112. {
  113.  char *BN;
  114.  
  115.  BN=FileName;
  116.  while (*FileName)
  117.   {
  118.    if ((*FileName==':')||(*FileName=='/')) BN=++FileName;
  119.    else FileName++;
  120.   }
  121.  return BN;
  122. }
  123.  
  124. LONG LoadErrorFile(char *ErrorName,char *SourceName)
  125.  
  126. {
  127.  FILE *ErrorFile;
  128.  char Buffer[256],ThisName[128],*Ptr;
  129.  struct Error *NextError;
  130.  
  131.  while (ErrorList.lh_Head->ln_Succ)
  132.   {
  133.    NextError=(struct Error *)ErrorList.lh_Head;
  134.    RemHead (&ErrorList);
  135.    free (NextError);
  136.   }
  137.  
  138.  if (ErrorFile=fopen(ErrorName,"r"))
  139.   {
  140.    while (fgets(Buffer,255,ErrorFile))
  141.     {
  142.      if (Ptr=strchr(Buffer,'\n')) *Ptr='\0';
  143.      if (NextError=malloc(sizeof(struct Error)))
  144.       {
  145.        if ((sscanf(Buffer,"%s %ld %s",ThisName,&NextError->Err_Line,NextError->Err_Text)==3)&&
  146.            (strcmp(SourceName,ThisName)==0))
  147.         {
  148.          strcpy (NextError->Err_Text,strchr(strchr(Buffer,' ')+1L,' ')+1L);
  149.          AddTail (&ErrorList,&NextError->Err_Node);
  150.          printf ("LE INSERT: %ld %s\n",NextError->Err_Line,NextError->Err_Text);
  151.         }
  152.        else
  153.         {
  154. #ifdef DEBUG
  155.          printf ("LE IGNORE: %s\n",Buffer);
  156. #endif
  157.          free (NextError);
  158.         }
  159.       }
  160.      else
  161.       {
  162.        fclose (ErrorFile);
  163.        return FALSE;
  164.       }
  165.     }
  166.    fclose (ErrorFile);
  167.    return TRUE;
  168.   }
  169.  
  170.  return FALSE;
  171. }
  172.  
  173. UBYTE *StripString(UBYTE *From)
  174.  
  175. {
  176.  UBYTE *To,*Ptr;
  177.  
  178.  if (To=CreateArgstring(From,strlen(From)))
  179.   {
  180.    Ptr=To;
  181.    while (*From==' ') From++;
  182.  
  183.    while ((*From!='\0')&&(*From!='\n')&&(*From!='\r')) *Ptr++=*From++;
  184.    *Ptr='\0';
  185.   }
  186.  
  187.  return To;
  188. }
  189.  
  190. LONG ParseCommand(UBYTE *Command,LONG *Done)
  191.  
  192. {
  193.  ULONG Index,Length;
  194.  static char FileName[128];
  195.  static LONG FileOpen=FALSE;
  196.  static UBYTE CmdBuffer[144];
  197.  struct Error *NextError;
  198.  
  199.  for (Index=0L; Commands[Index]!=NULL; Index++)
  200.   {
  201.    Length=strlen(Commands[Index]);
  202.    if ((strnicmp(Commands[Index],Command,Length)==0L)&&
  203.        ((Command[Length]==' ')||(Command[Length]=='\0')))
  204.     {
  205.      Command+=Length;
  206.      while (*Command==' ') Command++;
  207.      break;
  208.     }
  209.   }
  210.  switch (Index)
  211.   {
  212.    case 0:
  213.     strcpy (FileName,Command+2L);
  214.     sprintf (CmdBuffer,"SRIOpen %s",FileName);
  215.     if (FileOpen=SendRexxMsg(CmdBuffer)) return RC_OK;
  216.     return RC_WARN;
  217.    case 1:
  218.     if (!FileOpen) return RC_WARN;
  219.  
  220.     if (LoadErrorFile(Command,BaseName(FileName))) return RC_OK;
  221.     return RC_WARN;
  222.    case 2:
  223.     if (!FileOpen) return RC_WARN;
  224.  
  225.     if (ErrorList.lh_Head->ln_Succ)
  226.      {
  227.       NextError=(struct Error *)ErrorList.lh_Head;
  228.       RemHead (&ErrorList);
  229.       sprintf (CmdBuffer,"SRIShowError %s %ld %s",FileName,
  230.                NextError->Err_Line,NextError->Err_Text);
  231.      }
  232. #ifdef GERMAN
  233.     else sprintf (CmdBuffer,"SRIShowError %s 0 Keine weiteren Fehler !",FileName);
  234. #else
  235.     else sprintf (CmdBuffer,"SRIShowError %s 0 No more Errors !",FileName);
  236. #endif
  237.  
  238.     if (SendRexxMsg(CmdBuffer)) return RC_OK;
  239.     else return RC_WARN;
  240.    case 3:
  241.     *Done=TRUE;
  242.     return RC_OK;
  243.   }
  244.  
  245.  return RC_ERROR;
  246. }
  247.  
  248. void main(void)
  249.  
  250. {
  251.  struct MsgPort *SRIRexxPort;
  252.  struct RexxMsg *InRexxMsg;
  253.  LONG Done;
  254.  UBYTE *CmdString;
  255.  
  256. #ifndef DEBUG
  257.  if (_Backstdout) Close (_Backstdout);
  258. #endif
  259.  
  260.  if ((RexxSysBase=(struct RxsLib *)OpenLibrary("rexxsyslib.library",33L))==NULL) exit (10L);
  261.  if ((SRIRexxPort=CreateRexxPort(LSE_PORT_NAME))==NULL)
  262.   {
  263.    CloseLibrary (&RexxSysBase->rl_Node);
  264.    exit (10L);
  265.   }
  266.  
  267.  Done=FALSE;
  268.  NewList (&ErrorList);
  269.  while (!Done)
  270.   {
  271.    (void)WaitPort(SRIRexxPort);
  272.    InRexxMsg=(struct RexxMsg *)GetMsg(SRIRexxPort);
  273.    if (InRexxMsg->rm_Args[0])
  274.     {
  275.      if (CmdString=StripString(InRexxMsg->rm_Args[0]))
  276.       {
  277. #ifdef DEBUG
  278.        printf ("IN: %s\n",CmdString);
  279. #endif
  280.        SetResult (InRexxMsg,ParseCommand(CmdString,&Done));
  281.        DeleteArgstring (CmdString);
  282.       }
  283.     }
  284.    ReplyMsg (&InRexxMsg->rm_Node);
  285.   }
  286.  
  287.  DeletePort (SRIRexxPort);
  288.  CloseLibrary (&RexxSysBase->rl_Node);
  289.  
  290.  exit (0L);
  291. }
  292.